#include "ProtocolSwitch.h"
#include "DevModbusDeal.h"
#include <stdlib.h>
#include "DevRecode.h"
#include "util.h"

//tar 目标单位
//src 源数值单位
u32 unit_converter(u32 data,double tar,double src)
{
    data=(u32)(data*src/tar);
	return data;
}


/**
 * @brief 将 BCD 码转换为二进制整数
 * @param pData 指向 BCD 码数据的指针（每个字节存储 2 个十进制数字）
 * @param len BCD 码的字节长度
 * @return 转换后的二进制整数（u32），如果 BCD 码非法则返回 0
 */
uint32_t BcdToBin(uint8_t *pData, uint8_t len)
{
    if (pData == NULL || len == 0) {
        return 0; // 无效输入
    }

    uint32_t result = 0;

    for (uint8_t i = 0; i < len; i++) {
        uint8_t high_nibble = (pData[i] >> 4) & 0x0F; // 高 4 位（十位）
        uint8_t low_nibble = pData[i] & 0x0F;         // 低 4 位（个位）

        // 检查 BCD 码是否合法（0~9）
        if (high_nibble > 9 || low_nibble > 9) {
            return 0; // 非法 BCD 码
        }

        // 合并十位和个位，并累加到结果
        result = result * 100 + high_nibble * 10 + low_nibble;
    }

    return result;
}

/**
 * @brief 按大端方式拷贝内存（src -> des）
 * @param des 目标缓冲区（必须预分配足够空间）
 * @param src 源缓冲区
 * @param len 拷贝的字节数
 * @note 如果 src 是小端数据，会被转换为大端格式存入 des；
 *       如果 src 本身是大端数据，则直接拷贝。
 */
void memrcpy(uint8_t *des, const uint8_t *src, uint16_t len)
{
    if (des == NULL || src == NULL || len == 0) {
        return; // 安全检查
    }

    // 从后往前拷贝，确保多字节数据（如 u16/u32）按大端顺序存储
    for (uint16_t i = 0; i < len; i++) {
        des[i] = src[len - 1 - i]; // 反转字节顺序
    }
}

u8 ascii_char_to_u8(char c)
{
    if (c >= '0' && c <= '9') {
        return (uint8_t)(c - '0'); // 例如 '1' -> 1
    }
    else { 
        return 0; // 或者报错
    }
}

/**
 * @brief 将二进制数转换为小端序BCD码
 * @param val  输入的二进制数值
 * @param pData 输出缓冲区（需预先分配足够空间）
 * @param len  期望的BCD字节数（如len=4，可表示最大99999999）
 * @note  若转换结果超出len指定的字节数，高位会被截断
 */
void BinToBcd(u32 val, u8* pData, u8 len)
{
    if (!pData || len == 0) return;

    // 清零输出缓冲区
    for (u8 i = 0; i < len; i++) {
        pData[i] = 0;
    }

    // 逐位转换（小端序：低位字节在前）
    u8 pos = 0;
    while (val > 0 && pos < len) {
        u8 digit = val % 10;       // 取最低位数字
        val /= 10;                // 移除已处理位

        // 合并到当前字节（小端序：新数字放在字节低4位）
        pData[pos] |= (digit << 0); // 写入当前字节的低4位

        // 处理下一个十进制位
        digit = val % 10;
        val /= 10;
        pData[pos] |= (digit << 4); // 写入当前字节的高4位

        pos++; // 处理下一个字节
    }
}

// type	//参数类型
// *writebuf //发送modbus的数组
// devLen		//逆变器设备对应参数的数据长度，字节长度
// gdLen		//广东协议的数据长度
// GD_k		//广东协议的精度
// INV_k		//逆变器设备对应参数精度
void  DealData_type(u32 data,u8 type,u8*writebuf,u8 devLen,u8 gdLen,float GD_k,float INV_k)
{
	//u16 data_u16;
	//s16 data_s16;
	s32 data_s32;
	u32 data_u32;
	
    switch (gdLen)
	{
		case gd_data_2:
		{ 
			if((invSendFrame.data[1]&BIT7)==BIT7)
			{
				invSendFrame.data[1]&=(~BIT7);
				data_u32=BcdToBin(invSendFrame.data,gdLen);
				data_s32=-unit_converter(data_u32,INV_k,GD_k);
				memrcpy(writebuf, (u8*)&(data_s32), devLen);
			}
			else{
				data_u32=BcdToBin(invSendFrame.data,gdLen);
				data_u32=unit_converter(data_u32,INV_k,GD_k);
				memrcpy(writebuf, (u8*)&(data_u32), devLen);
			}	
			break;		
		}

		case gd_data_4:
		{
			if((invSendFrame.data[3]&BIT7)==BIT7)
			{
				invSendFrame.data[3]&=(~BIT7);
				data_u32=BcdToBin(invSendFrame.data,gdLen);
				data_s32=-unit_converter(data_u32,INV_k,GD_k);
				memrcpy(writebuf, (u8*)&(data_s32), devLen);
			}
			else{
				data_u32=BcdToBin(invSendFrame.data,gdLen);
				data_u32=unit_converter(data_u32,INV_k,GD_k);
				memrcpy(writebuf, (u8*)&(data_u32), devLen);
			}	
			break;		
		}
	}
}

//百分比按额定功率,输出是data
u32 DataEventGet_data(u32 BcdRataData,u32 BcdData,u32 gd_k,u8 pctLen,u8 dataLen)
{
    s32 data_s32;
    u32 data_u32;

    s32 rataData;
    s32 pctdata;
    if((BcdRataData&BIT1F)==BIT1F)//判断是负数
    {
        BcdRataData&=(~BIT1F);
        rataData = 0-BcdToBin((u8*)&BcdRataData,dataLen);
    } else {
        rataData=BcdToBin((u8*)&BcdRataData,dataLen);
    }

    if((BcdData&BITF)==BITF)//判断是负数)
    {
        BcdData&=(~BITF);
        pctdata = 0-BcdToBin((u8*)&BcdData,pctLen);
    } else {
        pctdata=BcdToBin((u8*)&BcdData,pctLen);
    }

    data_s32=(rataData*pctdata)/(s32)gd_k;
    data_u32 = data_s32;

    return data_u32;
}


//百分比按额定功率,输出是BCD
u32 DataEventGet_bcd(u32 BcdRataData,u32 BcdData,u32 gd_k,u8 pctLen,u8 dataLen)
{
    s32 data_s32;
    u32 data_u32;
    u32 outData;

    s32 rataData;
    s32 pctdata;
    if((BcdRataData&BIT1F)==BIT1F)//判断是负数)
    {
        BcdRataData&=(~BIT1F);
        rataData = 0-BcdToBin((u8*)&BcdRataData,dataLen);
    }else{
        rataData=BcdToBin((u8*)&BcdRataData,dataLen);
    }

    if((BcdData&BITF)==BITF)//判断是负数)
    {
        BcdData&=(~BITF);
        pctdata = 0-BcdToBin((u8*)&BcdData,pctLen);
    }else{
        pctdata=BcdToBin((u8*)&BcdData,pctLen);
    }

    data_s32=(rataData*pctdata)/(s32)gd_k;
    data_u32 = abs(data_s32);

    BinToBcd(data_u32 ,(u8*)&outData,dataLen);
    if (data_s32 < 0){
        outData|=BIT1F;
    }

    return outData;
}

//将下发的BCD额定值和BCD处理获取百分比   d->pct
void Deal_dataToPct(u32 bcdRataData,u32 bcddata,u8*writebuf,u8 len,double INV_k,u8 devLen)
{
    s32 rataData,data;
    float pctData;
    // s32 data;
    s32 outData;
    if((bcdRataData&BIT1F)==BIT1F)//判断是负数)
    {
        bcdRataData&=(~BIT1F);
        rataData = 0-BcdToBin((u8*)&bcdRataData,len);
    }else
    {
        rataData=BcdToBin((u8*)&bcdRataData,len);
    }

    if((bcddata&BIT1F)==BIT1F)//判断是负数)
    {
        bcddata&=(~BIT1F);
        data = 0-BcdToBin((u8*)&bcddata,len);
    }else
    {
        data=BcdToBin((u8*)&bcddata,len);
    }

    pctData=(float)data/rataData*pct_d_k;
    outData = (s32)round(pctData * INV_k);  // 四舍五入取整
    memrcpy(writebuf,(u8*)&outData,devLen);
}


void YtWriteData(u16 typeItem, Recode_Type *cur_regs, u8*writebuf, u8 len )
{
    u8 devNum=invSendFrame.devNum;
    s32 convertData;//百分比转换得控制值
    YtItemg *yt_set;
    YtItemg_pct *yt_set_pct;

    double INV_k;
    double GD_k;//广东协议精度

    switch(typeItem)
    {
        case p_set_num:
            GD_k=p_gd_k;
            yt_set=cur_regs[typeItem].p;

            yt_set_pct=cur_regs[typeItem].p;
            if(yt_set_pct->funtion==pct_ctr)
            {
                yt_set_pct=cur_regs[typeItem].p;
                memcpy((u8*)&intermediateDev[devNum].activePowerCtr,invSendFrame.data,p_len);
                INV_k=(double)yt_set_pct->mult/(double)yt_set_pct->div;
                Deal_dataToPct(5,intermediateDev[devNum].activePowerCtr,writebuf,p_len,INV_k,p_pct_len);
            }
            else if(yt_set_pct->funtion==data_ctr)
            {
                GD_k=p_gd_k;
                memcpy((u8*)&intermediateDev[devNum].activePowerCtr,invSendFrame.data,p_len);
                INV_k=(double)yt_set_pct->mult/(double)yt_set_pct->div;
                DealData_type(intermediateDev[devNum].activePowerCtr,cur_regs[typeItem].type,writebuf,len,p_len,GD_k,INV_k);

            }
        break;

        case q_set_num:
            GD_k=q_gd_k;
            yt_set=cur_regs[typeItem].p;

            yt_set_pct=cur_regs[typeItem].p;
            if(yt_set_pct->funtion==pct_ctr)
            {
                // GD_k=p_pct_gd_k;
                yt_set_pct=cur_regs[typeItem].p;
                memcpy((u8*)&intermediateDev[devNum].reActivePowerCtr,invSendFrame.data,q_len);
                INV_k=(double)yt_set_pct->mult/(double)yt_set_pct->div;
                Deal_dataToPct(intermediateDev[devNum].ratedReactivePower,
                               intermediateDev[devNum].reActivePowerCtr,
                               writebuf,q_len,INV_k,q_pct_len);
            }
            else if(yt_set_pct->funtion==data_ctr)
            {
                memcpy((u8*)&intermediateDev[devNum].reActivePowerCtr,invSendFrame.data,q_len);
                INV_k=(double)yt_set->mult/(double)yt_set->div;
                DealData_type(intermediateDev[devNum].reActivePowerCtr,
                              cur_regs[typeItem].type,writebuf,len,q_len,GD_k,INV_k);

            }
        break;

        case pf_set_num:
            GD_k=pf_gd_k;
            yt_set=cur_regs[typeItem].p;
            memcpy((u8*)&intermediateDev[devNum].powerFactor,invSendFrame.data,pf_len);
            INV_k=(double)yt_set->mult/(double)yt_set->div;
            DealData_type((u32)intermediateDev[devNum].powerFactor,cur_regs[typeItem].type,
                          writebuf,len,pf_len,GD_k,INV_k);
        break;

        case p_pct_set_num:
            GD_k=p_pct_gd_k;
            yt_set_pct=cur_regs[typeItem].p;
            memcpy((u8*)&intermediateDev[devNum].perActivePower,invSendFrame.data,p_pct_len);
            INV_k=(double)yt_set_pct->mult/(double)yt_set_pct->div;
            DealData_type((u32)intermediateDev[devNum].perActivePower,
                          cur_regs[typeItem].type,writebuf,
                          len,p_pct_len,GD_k,INV_k);
        break;

        case q_pct_set_num:
            GD_k=q_pct_gd_k;
            memcpy((u8*)&intermediateDev[devNum].perReactivePower,invSendFrame.data,q_pct_len);
            yt_set_pct=cur_regs[typeItem].p;
            INV_k=(double)yt_set_pct->mult/(double)yt_set_pct->div;
            DealData_type((u32)intermediateDev[devNum].perReactivePower,
                          cur_regs[typeItem].type,writebuf,
                          len,q_pct_len,GD_k,INV_k);
        break;

        default:
        break;
    }
}



/// @typeItem 类型
/// @writebuf 写modbus数组
/// @devNum
/// @regNum dest_type 目标数据类型标识
/// @cur_regs dest_data 目标数据指针（转换结果存放位置）
void Get_sendData(u16 typeItem,u8*writebuf,u8 devNum,u8 regNum,Recode_Type *cur_regs)
{
	//u32 convertData; //用于转换数据
	YkItemg *ykitemg;
	switch (typeItem)
	{
		case  runStatus_wr_open:
			ykitemg=cur_regs[typeItem].p;
            memrcpy(writebuf,(u8*)&ykitemg->val_data,sizeof(u16));
		break;

        case  runStatus_wr_close:
			ykitemg=cur_regs[typeItem].p;
            memrcpy(writebuf,(u8*)&ykitemg->val_data,sizeof(u16));
		break;

        case p_set_model:
			ykitemg=cur_regs[typeItem].p;
			memrcpy(writebuf,(u8*)&ykitemg->val_data,sizeof(u16));
		break;

        case p_set_num:
            YtWriteData(typeItem,cur_regs,writebuf,regNum*2);
		break;

        case q_set_model:
			ykitemg=cur_regs[typeItem].p;
			memrcpy(writebuf,(u8*)&ykitemg->val_data,sizeof(u16));
		break;

        case q_set_num:
            YtWriteData(typeItem,cur_regs,writebuf,regNum*2);
		break;

        case pf_set_model:
			ykitemg=cur_regs[typeItem].p;
			memrcpy(writebuf,(u8*)&ykitemg->val_data,sizeof(u16));
		break;

        case pf_set_num:
            YtWriteData(typeItem,cur_regs,writebuf,regNum*2);
		break;

        case p_pct_set_model:
			ykitemg=cur_regs[typeItem].p;
			memrcpy(writebuf,(u8*)&ykitemg->val_data,sizeof(u16));
		break;

        case p_pct_set_num:
            YtWriteData(typeItem,cur_regs,writebuf,regNum*2);
		break;

        case AISWEI_q_set_model:
			ykitemg=cur_regs[typeItem].p;
			memrcpy(writebuf,(u8*)&ykitemg->val_data,sizeof(u16));
		break;

        case q_pct_set_model:
			ykitemg=cur_regs[typeItem].p;
			memrcpy(writebuf,(u8*)&ykitemg->val_data,sizeof(u16));
		break;

        case q_pct_set_num:
            YtWriteData(typeItem,cur_regs,writebuf,regNum*2);
		break;

        default:
            break;
    }
}
//只写
Get_Frame_Type Find_Frame_wr(u8*writebuf,Recode_Type *cur_regs,u8 typeItem)
{
    Get_Frame_Type getFrame;

    u16 send_reg_count = 0;
    //获取地址，同时把无效地址放到已发送队列
    for (u16 i = 0; i < invSendFrame.regsSize; i++){
        //已经发送的寄存器不再发送
        bool find = false;
        for (u16 j = 0; j < invSendFrame.regsHaveSendSize; j++){
            if (invSendFrame.regs[i].reg_flag == invSendFrame.regsHaveSend[j].reg_flag &&
                invSendFrame.regs[i].functype == invSendFrame.regsHaveSend[j].functype){
                find = true;
                break;
            }
        }
        if (find )
            continue;

        //不能存在无效的写寄存器，如果该类型的逆变器不支持这个功能，需要直接返回错误信息给plc发送端。
        if (cur_regs[invSendFrame.regs[i].reg_flag].flag == inValidFlag){
            send_reg_count = 0; //本次写入操作需要取消
            break;
        }

        //写操作不判断连续地址，一个个数据项单独写，
        //比如：运行状态、功率因数、有功功率百分比调节，
        //这些数据项需要单独modbus指令依次下发。
        if (send_reg_count <= 0) { //只获取一个数据项，如此判断，是为了遍历所有的寄存器，判断是否存在无效数据项
            invSendFrame.regsNextSend[invSendFrame.regsNextSendSize].reg_flag = invSendFrame.regs[i].reg_flag;
            invSendFrame.regsNextSend[invSendFrame.regsNextSendSize].functype = invSendFrame.regs[i].functype;
            send_reg_count += cur_regs[invSendFrame.regs[i].reg_flag].reg_count;
            invSendFrame.regsNextSendSize++;
        }
    }

    //返回需要发送的起始寄存器地址值、寄存器数量以及需要写入值
    getFrame.regNum = 0;

    if (invSendFrame.regsNextSendSize > 0){
        getFrame.regAddr = cur_regs[invSendFrame.regsNextSend[0].reg_flag].addr;
        getFrame.regNum  = send_reg_count;
        invSendFrame.curFuncType = invSendFrame.regsNextSend[0].functype;
        if(invSendFrame.curFuncType==write)
        {
            getFrame.fc = cur_regs[invSendFrame.regsNextSend[0].reg_flag].fc_wr;
            Get_sendData(invSendFrame.regsNextSend[0].reg_flag,writebuf,invSendFrame.devNum,getFrame.regNum,cur_regs);
        }
        else if(invSendFrame.curFuncType==read)
        {
            getFrame.fc = cur_regs[invSendFrame.regsNextSend[0].reg_flag].fc_rd;
        }
    }
    return getFrame;
}
 
Get_Frame_Type Find_Frame_rd(Recode_Type *cur_regs)
{
	u16 pre_reg_addr = 0xffff; 
	u8 pre_reg_count = 1;
	u8 send_reg_count = 0; 
	bool reg_continuous = true;
	Get_Frame_Type getFrame;
	//获取连续地址，同时把无效地址放到已发送队列
	
	for (u16 i = 0; i < invSendFrame.regsSize; i++){
		//已经发送的寄存器不再发送
		bool find = false;
		for (u16 j = 0; j < invSendFrame.regsHaveSendSize; j++){
			if (invSendFrame.regs[i].reg_flag == invSendFrame.regsHaveSend[j].reg_flag){
				find = true;
				break;
			}
		}
		if (find ){
			continue;
		}

		//无效寄存器直接放到已发送队列
		if (cur_regs[invSendFrame.regs[i].reg_flag].flag == inValidFlag){
			invSendFrame.regsHaveSend[invSendFrame.regsHaveSendSize++].reg_flag = invSendFrame.regs[i].reg_flag;
			
			u8 failedcode = 0xFF; 
			u16 bytecount = cur_regs[invSendFrame.regs[i].reg_flag].reg_count * 2;
			invSendFrame.regValue[invSendFrame.regs[i].reg_flag].len = 0;
			for(u16 i = 0; i < bytecount; i++ ){
				memcpy(invSendFrame.regValue[invSendFrame.regs[i].reg_flag].data, (u8*)&failedcode, 1);
				invSendFrame.regValue[invSendFrame.regs[i].reg_flag].len += 1;
			}
			continue;
		}
		//发现不连续寄存器不退出，只是不再缓存需要发送的寄存器，主要是为了不漏掉所有的无效寄存器
		if (!reg_continuous){	
			continue;
		}
		//判断是否为连续地址
        if (pre_reg_addr != 0xffff)
        {
			if ((pre_reg_addr + pre_reg_count) != cur_regs[invSendFrame.regs[i].reg_flag].addr){
				reg_continuous = false;
			}
		}
		//获取连续地址	
		if (reg_continuous){
			invSendFrame.regsNextSend[invSendFrame.regsNextSendSize].reg_flag= invSendFrame.regs[i].reg_flag;
			invSendFrame.regsNextSend[invSendFrame.regsNextSendSize].functype= invSendFrame.regs[i].functype;
			send_reg_count += cur_regs[invSendFrame.regs[i].reg_flag].reg_count;

			pre_reg_addr =  cur_regs[invSendFrame.regs[i].reg_flag].addr;
			pre_reg_count = cur_regs[invSendFrame.regs[i].reg_flag].reg_count;
			invSendFrame.regsNextSendSize++;
		}
	}	

	//返回需要发送的起始寄存器地址值和寄存器数量
	getFrame.regNum = 0;
	if (invSendFrame.regsNextSendSize > 0){
		getFrame.fc 		= cur_regs[invSendFrame.regsNextSend[0].reg_flag].fc_rd;
		getFrame.regAddr 	= cur_regs[invSendFrame.regsNextSend[0].reg_flag].addr;
		getFrame.regNum 	= send_reg_count;
		invSendFrame.curFuncType = invSendFrame.regsNextSend[0].functype;
	}
	return getFrame;
}


/**
 * @brief getSendDate  发送处理
 * @param typeItem
 * @param writebuf
 * @return
 */
Get_Frame_Type getSendDate(u8 typeItem,u8*writebuf)
{
	invSendFrame.recflag=true;

	Get_Frame_Type getFrame;
	Reg_Bank *regbank = FindRegBank(&invSendFrame.dv);
	
	if(typeItem==ExcepTrigLimit||typeItem==T_P_SET||typeItem==T_P_PCT_SET)
	invSendFrame.recflag=false;
	
    if(regbank==NULL) //异常处理
	{
		printf("regbank==NULLSend\n");
		getFrame.regNum=0;
		return getFrame;
	}
	Recode_Type *cur_regs = regbank->regs;

	if (invSendFrame.function==read){
		getFrame = Find_Frame_rd(cur_regs); 
	}else if (invSendFrame.function==write)//写
	{
		getFrame = Find_Frame_wr(writebuf,cur_regs,typeItem); 
	}
	return getFrame;
}



u32 rearrangeBytes(u8 type, u8 *original)
{
    FloatBytes rearranged;
    u8 abcdOrder[4] = { 0, 1, 2, 3 }; // 原始顺序
    u8 dcbaOrder[4] = { 3, 2, 1, 0 }; // 反向顺序
    u8 badcOrder[4] = { 1, 0, 3, 2 }; // 交换两对字节
    u8 cdabOrder[4] = { 2, 3, 0, 1 }; // 交叉排列
    u8 order[4]={0};
    switch (type)
    {
        case abcdtype:
        memrcpy(order,abcdOrder,4);
        break;
        case dcbatype:
        memrcpy(order,dcbaOrder,4);
        break;
        case badctype:
        memrcpy(order,badcOrder,4);
        break;
        case cdabtype:
        memrcpy(order,cdabOrder,4);
        break; 
    }
    
    for (int i = 0; i < 4; ++i) {
        rearranged.bytes[i] = original[order[i]];       //u32和数组大小端
    }
    return rearranged.Value;
}

/**
 * @brief ReadToBCD 获取的数值转成BCD，需要判断转出的类型，类型和转出长度不一定匹配，一个是输入的，一个输出的
 * @param putIn     输入
 * @param out       输出
 * @param type      参数类型
 * @param tar       目标单位
 * @param src       源单位
 * @param outLen    输出长度
 */
void  ReadToBCD(u8 *putIn, u8 *out,u8 type,double tar,double src,u8 outLen)
{
    u16 data_u16=0;
    s16 data_s16=0;
    s32 data_s32=0;
    u32 data_u32=0;
    float data_f32=0;
    u32 data=0;

    switch(type)
    {
        case type_u16:
			data_u16=LoadInt16_BigE(putIn);
			data=unit_converter((u32)data_u16,tar,src);
			BinToBcd(data,out,outLen);
        break;

        case type_s16:
            data_s16=(LoadInt16_BigE(putIn));
            if(data_s16<0)
            {
                data_s16=(abs)(data_s16);
				u32 data=unit_converter((u32)data_s16,tar,src);
				BinToBcd(data,out,outLen);
				out[outLen-1]|=BIT7;
            }
            else
            {
                u32 data=data_s16;
				data=unit_converter(data,tar,src);
				BinToBcd(data,out,outLen);
            }
        break; 

        case type_u32_abcd:
            data_u32=rearrangeBytes(abcdtype,putIn);
            data=unit_converter((u32)data_u32,tar,src);
            BinToBcd(data,out,outLen);
        break;

        case type_u32_dcba:
            data_u32=rearrangeBytes(dcbatype,putIn);
            data=unit_converter((u32)data_u32,tar,src);
            BinToBcd(data,out,outLen);
        break;

        case type_u32_badc:
            data_u32=rearrangeBytes(badctype,putIn);
            data=unit_converter((u32)data_u32,tar,src);
            BinToBcd(data,out,outLen);
        break;

        case type_u32_cdab:
            data_u32=rearrangeBytes(cdabtype,putIn);
            data=unit_converter((u32)data_u32,tar,src);            
            BinToBcd(data,out,outLen);
        break;

        case type_float_abcd:
            data=rearrangeBytes(abcdtype,putIn);
            memcpy((u8*)&data_f32,(u8*)&data,4);
            data=(u32)(((round(data_f32 * 10000) / 10000))*src/tar);
            BinToBcd(data,out,outLen);
        break;

        case type_float_dcba:
            data=rearrangeBytes(dcbatype,putIn);
            memcpy((u8*)&data_f32,(u8*)&data,4);
            data=(u32)(((round(data_f32 * 10000) / 10000))*src/tar);
            BinToBcd(data,out,outLen);
        break;

        case type_float_badc:
            data=rearrangeBytes(badctype,putIn);
            memcpy((u8*)&data_f32,(u8*)&data,4);
            data=(u32)(((round(data_f32 * 10000) / 10000))*src/tar);
            BinToBcd(data,out,outLen);
        break;

        case type_float_cdab:
            data=rearrangeBytes(cdabtype,putIn);
            memcpy((u8*)&data_f32,(u8*)&data,4);
            data=(u32)(((round(data_f32 * 10000) / 10000))*src/tar);
            BinToBcd(data,out,outLen);
        break;

        case type_s32_abcd:
             data_s32=rearrangeBytes(abcdtype,putIn);
            if(data_s32<0)
            {
                data_s32=(abs)(data_s32);
				u32 data=unit_converter((u32)data_s32,tar,src);
				BinToBcd(data,out,outLen);
				out[outLen-1]|=BIT7;
               
            }
            else
            {
				u32 data=unit_converter((u32)data_s32,tar,src);
				BinToBcd(data,out,outLen);
            }
        break;

        case type_s32_dcba:
             data_s32=rearrangeBytes(dcbatype,putIn);
            if(data_s32<0)
            {
                data_s32=(abs)(data_s32);
				u32 data=unit_converter((u32)data_s32,tar,src);
				BinToBcd(data,out,outLen);
				out[outLen-1]|=BIT7;
            }
            else
            {
				u32 data=unit_converter((u32)data_s32,tar,src);
				BinToBcd(data,out,outLen);
            }
        break;
        
        case type_s32_badc:
            data_s32=rearrangeBytes(badctype,putIn);
            if(data_s32<0)
            {
                data_s32=(abs)(data_s32);
				u32 data=unit_converter((u32)data_s32,tar,src);
				BinToBcd(data,out,outLen);
				out[outLen-1]|=BIT7;
            }
            else
            {
				u32 data=unit_converter((u32)data_s32,tar,src);
				BinToBcd(data,out,outLen);
            }
        break;

        case type_s32_cdab:
             data_s32=rearrangeBytes(cdabtype,putIn);
            if(data_s32<0)
            {
                data_s32=(abs)(data_s32);
				u32 data=unit_converter((u32)data_s32,tar,src);
				BinToBcd(data,out,outLen);
				out[outLen-1]|=BIT7;
            }
            else
            {
				u32 data=unit_converter((u32)data_s32,tar,src);
				BinToBcd(data,out,outLen);
            }
        break;

        case  type_s16_sign:
            data_u16=(LoadInt16_BigE(putIn));
            if((data_u16&BITF)==BITF)//负数
            {
               data_u16&= (~BITF);
               u32 data=unit_converter((u32)data_u16,tar,src);
               BinToBcd(data,out,outLen);
               out[outLen-1]|=BIT7;
            }
            else 
            {
               u32 data=unit_converter((u32)data_u16,tar,src);
               BinToBcd(data,out,outLen);
            }
        break;

        case type_s32_sign://原码
            data_u32=(LoadInt32_BigE(putIn));
            if((data_u32&BIT1F)==BIT1F)//负数
            {
               data_u32&= (~BIT1F);
               u32 data=unit_converter((u32)data_u32,tar,src);
               BinToBcd(data,out,outLen);
               out[outLen-1]|=BIT1F;
            }
            else 
            {
               u32 data=unit_converter((u32)data_u32,tar,src);
               BinToBcd(data,out,outLen);
            }
        break;

        default: break;
    }
}

u8 YCReadDeal(u8*DataBuf,u8 *putIn,u8 typeItemNum,Recode_Type *cur_regs)
{	
    YcItemg *yc_set;
    // u8*DataBuf;
    u8 len,status=true;
    double INV_k;
    double GD_k;//广东协议精度

    switch(typeItemNum)
    {
        case vol_a:
        case vol_b:
        case vol_c:
        {
            GD_k=vol_gd_k;
            len=vol_len;
            INV_k=0.1;
            break;
        }

        case cur_a:
        case cur_b:
        case cur_c:
        {
            GD_k=cur_gd_k;
            len=cur_len;
            INV_k=0.1;
            break;
        }

        case p_a:
        case p_b:
        case p_c:
        case p_all:
        {
            GD_k=p_gd_k;
            len=p_len;
            INV_k=0.1;
            break;
        }

        case q_a:
        case q_b:
        case q_c:
        case q_all:
        {
            GD_k=q_gd_k;
            len=q_len;
            INV_k=1;
            break;
        }

        case pf_a:
        case pf_b:
        case pf_c:
        case pf_all:
        {
            GD_k=pf_gd_k;
            len=pf_len;
            INV_k=0.001;
            break;
        }

        case rated_p:
        {
            GD_k=p_gd_k;
            len=p_len;
            INV_k=100;
            break;
        }

        case rated_q:
        {
            GD_k=q_gd_k;
            len=q_len;
            INV_k=100;
            break;
        }

        case deg:
        {
            GD_k=deg_gd_k;
            len=deg_len;
            INV_k=0.1;
            break;
        }

        case p_set_num:
        {
            GD_k=p_gd_k;
            len=p_len;
            INV_k=100;
            break;
        }

        case q_set_num:
        {
            GD_k=q_gd_k;
            len=q_len;
            INV_k=100;
            break;
        }

        case p_pct_set_num:
        {
            GD_k=p_pct_gd_k;
            len=p_pct_len;
            INV_k=0.1;
            break;
        }

        case q_pct_set_num:
        {
            GD_k=q_pct_gd_k;
            len=q_pct_len;
            INV_k=0.1;
            break;
        }

        case pf_set_num:
        {
            GD_k=pf_gd_k;
            len=pf_len;
            INV_k=0.001;
            break;
        }

        default:
            status=false;
        break;
    }
    yc_set=cur_regs[typeItemNum].p;

    ReadToBCD(putIn,DataBuf,cur_regs[typeItemNum].type,GD_k,INV_k,len);

    return status;
}

//求字节长度
u8 getDataLen(u8 type)
{
	switch(type)
	{
		case type_u16:
		case type_s16:
		return 2;
		break;

		case type_s32_abcd:
		case type_s32_dcba:
		case type_s32_badc:
		case type_s32_cdab:
		case type_u32_abcd:
		case type_u32_dcba:
		case type_u32_badc:
		case type_u32_cdab:
		case type_float_abcd:
		case type_float_dcba:
		case type_float_badc:
		case type_float_cdab:
		return 4;
		break;

		default :
		return 0;
		break;
	}
}

u8 CheckDevFunNew(u8 *DataBuf,u8* rxData)
{
	u8 len=0;
	u32 faildData=0xffffffff;
	u8 typeItem;
	u8 status;
	u8 devNum=invSendFrame.devNum;
	typeItem=invSendFrame.typeItem; 
	Reg_Bank *regbank = FindRegBank(&invSendFrame.dv);
	// Reg_Bank *regbank = FindRegBank(&invSendFrame.dv);
	if(regbank==NULL)//异常处理
	{
		len=0;
		return len;
	}
	Recode_Type *cur_regs = regbank->regs;
	switch (typeItem)
	{
		case VOL_BLOCK:{
			//保存发送队列里寄存器地址对应的值
			for (u16 i = 0; i < invSendFrame.regsNextSendSize; i++){
				u16 byte_count = 2 * cur_regs[invSendFrame.regsNextSend[i].reg_flag].reg_count;
				memcpy(invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].data,rxData,byte_count);
				rxData+=getDataLen(cur_regs[invSendFrame.regsNextSend[i].reg_flag].type);
				invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].len = byte_count;
				invSendFrame.regsHaveSend[invSendFrame.regsHaveSendSize++].reg_flag=invSendFrame.regsNextSend[i].reg_flag;
			}

			//清空发送队列
			invSendFrame.regsNextSendSize = 0;
			//接收完成
			if (invSendFrame.regsHaveSendSize >= invSendFrame.regsSize) {
				if(cur_regs[vol_a].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,vol_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[vol_a].data,vol_a,cur_regs);

					if(status==false)
					{
						len =0;
						return len;
					}
				}
				
				DataBuf += vol_len;
				len 	+= vol_len;

				if(cur_regs[vol_b].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,vol_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[vol_b].data,vol_b,cur_regs);

					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += vol_len;
				len 	+= vol_len;


				if(cur_regs[vol_c].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,vol_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[vol_c].data,vol_c,cur_regs);
				
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				
				DataBuf += vol_len;
				len 	+= vol_len;
			}
			return len;
		}
		break;

		case CUR_BLOCK:{
			
			//保存发送队列里寄存器地址对应的值
			for (u16 i = 0; i < invSendFrame.regsNextSendSize; i++){
				u16 byte_count = 2 * cur_regs[invSendFrame.regsNextSend[i].reg_flag].reg_count;
				memcpy(invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].data,rxData,byte_count);
				rxData+=getDataLen(cur_regs[invSendFrame.regsNextSend[i].reg_flag].type);
				invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].len = byte_count;
				invSendFrame.regsHaveSend[invSendFrame.regsHaveSendSize++].reg_flag=invSendFrame.regsNextSend[i].reg_flag;
			}
			//清空发送队列
			invSendFrame.regsNextSendSize = 0;
			//接收完成
			if (invSendFrame.regsHaveSendSize >= invSendFrame.regsSize) {
				if(cur_regs[cur_a].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,cur_len);
				}
				else
				{	
					status=YCReadDeal(DataBuf,invSendFrame.regValue[cur_a].data,cur_a,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += cur_len;
				len 	+= cur_len;

				if(cur_regs[cur_b].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,cur_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[cur_b].data,cur_b,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += cur_len;
				len 	+= cur_len;


				if(cur_regs[cur_c].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,cur_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[cur_c].data,cur_c,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				
				DataBuf += cur_len;
				len 	+= cur_len;

			}
			
			return len;
		}
		break;

		case P_BLOCK:{//瞬时有功功率数据块
				for (u16 i = 0; i < invSendFrame.regsNextSendSize; i++){
				u16 byte_count = 2 * cur_regs[invSendFrame.regsNextSend[i].reg_flag].reg_count;
				memcpy(invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].data,rxData,byte_count);
				rxData+=getDataLen(cur_regs[invSendFrame.regsNextSend[i].reg_flag].type);
				invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].len = byte_count;
				invSendFrame.regsHaveSend[invSendFrame.regsHaveSendSize++].reg_flag=invSendFrame.regsNextSend[i].reg_flag;
			}

			//清空发送队列
			invSendFrame.regsNextSendSize = 0;
			
			//接收完成
			if (invSendFrame.regsHaveSendSize >= invSendFrame.regsSize) {
				
			
				if(cur_regs[p_all].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,p_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[p_all].data,p_all,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += p_len;
				len 	+= p_len;
				
				if(cur_regs[p_a].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,p_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[p_a].data,p_a,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				
				DataBuf += p_len;
				len 	+= p_len;

				if(cur_regs[p_b].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,p_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[p_b].data,p_b,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}		
				DataBuf += p_len;
				len 	+= p_len;

				if(cur_regs[p_c].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,p_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[p_c].data,p_c,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += p_len;
				len 	+= p_len;
			}
			return len;
			break;
		}
		
	

		case Q_BLOCK:{//瞬时无功功率数据块
			for (u16 i = 0; i < invSendFrame.regsNextSendSize; i++){
				u16 byte_count = 2 * cur_regs[invSendFrame.regsNextSend[i].reg_flag].reg_count;
				memcpy(invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].data,rxData,byte_count);
				rxData+=getDataLen(cur_regs[invSendFrame.regsNextSend[i].reg_flag].type);
				invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].len = byte_count;
				invSendFrame.regsHaveSend[invSendFrame.regsHaveSendSize++].reg_flag=invSendFrame.regsNextSend[i].reg_flag;
			}

			//清空发送队列
			invSendFrame.regsNextSendSize = 0;
			
			//接收完成
			if (invSendFrame.regsHaveSendSize >= invSendFrame.regsSize) {
				if(cur_regs[q_all].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,q_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[q_all].data,q_all,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				
				DataBuf += q_len;
				len 	+= q_len;

				if(cur_regs[q_a].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,q_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[q_a].data,q_a,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += q_len;
				len 	+= q_len;

				if(cur_regs[q_b].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,q_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[q_b].data,q_b,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += q_len;
				len 	+= q_len;


				if(cur_regs[q_c].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,q_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[q_c].data,q_c,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += q_len;
				len 	+= q_len;


			}
			return len;
			break;
		}
		


		case FP_BLOCK:	////功率因数数据块
			{
			for (u16 i = 0; i < invSendFrame.regsNextSendSize; i++){
				u16 byte_count = 2 * cur_regs[invSendFrame.regsNextSend[i].reg_flag].reg_count;
				memcpy(invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].data,rxData,byte_count);
				rxData+=getDataLen(cur_regs[invSendFrame.regsNextSend[i].reg_flag].type);
				invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].len = byte_count;
				invSendFrame.regsHaveSend[invSendFrame.regsHaveSendSize++].reg_flag=invSendFrame.regsNextSend[i].reg_flag;
			}

			//清空发送队列
			invSendFrame.regsNextSendSize = 0;
			//接收完成
			if (invSendFrame.regsHaveSendSize >= invSendFrame.regsSize) {
				
				if(cur_regs[pf_all].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,pf_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[pf_all].data,pf_all,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}

				DataBuf += pf_len;
				len 	+= pf_len;

				if(cur_regs[pf_a].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,pf_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[pf_a].data,pf_a,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				
				DataBuf += pf_len;
				len 	+= pf_len;

				if(cur_regs[pf_b].flag==inValidFlag) 
				{
					memcpy(DataBuf,(u8*)&faildData,pf_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[pf_b].data,pf_b,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += pf_len;
				len 	+= pf_len;


				if(cur_regs[pf_c].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,pf_len);	
				}
				else
				{
					YCReadDeal(DataBuf,invSendFrame.regValue[pf_c].data,pf_c,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += pf_len;
				len 	+= pf_len;
			}
			return len;
		}
		break;

		case ALL_BLOCK:	///所有变量的数据块
		{
			for (u16 i = 0; i < invSendFrame.regsNextSendSize; i++){
				u16 byte_count = 2 * cur_regs[invSendFrame.regsNextSend[i].reg_flag].reg_count;
				memcpy(invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].data,rxData,byte_count);
				rxData+=getDataLen(cur_regs[invSendFrame.regsNextSend[i].reg_flag].type);
				invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].len = byte_count;
				invSendFrame.regsHaveSend[invSendFrame.regsHaveSendSize++].reg_flag=invSendFrame.regsNextSend[i].reg_flag;
			}

			//清空发送队列
			invSendFrame.regsNextSendSize = 0;
			
			//接收完成
			if (invSendFrame.regsHaveSendSize >= invSendFrame.regsSize) {

				//电压
				if(cur_regs[vol_a].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,vol_len);
				} 
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[vol_a].data,vol_a,cur_regs);
					
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += vol_len;
				len 	+= vol_len;

				if(cur_regs[vol_b].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,vol_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[vol_b].data,vol_b,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += vol_len;
				len 	+= vol_len;


				if(cur_regs[vol_c].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,vol_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[vol_c].data,vol_c,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += vol_len;
				len 	+= vol_len;

				//电流
				if(cur_regs[cur_a].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,cur_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[cur_a].data,cur_a,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += cur_len;
				len 	+= cur_len;

				if(cur_regs[cur_b].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,cur_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[cur_b].data,cur_b,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += cur_len;
				len 	+= cur_len;


				if(cur_regs[cur_c].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,cur_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[cur_c].data,cur_c,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += cur_len;
				len 	+= cur_len;

				//有功功率
				if(cur_regs[p_all].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,p_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[p_all].data,p_all,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += p_len;
				len 	+= p_len;
				
				if(cur_regs[p_a].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,p_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[p_a].data,p_a,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += p_len;
				len 	+= p_len;

				if(cur_regs[p_b].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,p_len);
				}
				else
				{
				status=YCReadDeal(DataBuf,invSendFrame.regValue[p_b].data,p_b,cur_regs);
				if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += p_len;
				len 	+= p_len;

				if(cur_regs[p_c].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,p_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[p_c].data,p_c,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += p_len;
				len 	+= p_len;

				//无功功率

				if(cur_regs[q_all].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,p_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[q_all].data,q_all,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += q_len;
				len 	+= q_len;

				if(cur_regs[q_a].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,q_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[q_a].data,q_a,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += q_len;
				len 	+= q_len;

				if(cur_regs[q_b].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,q_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[q_b].data,q_b,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += q_len;
				len 	+= q_len;


				if(cur_regs[q_c].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,q_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[q_c].data,q_c,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += q_len;
				len 	+= q_len;

				//功率因数
				if(cur_regs[pf_all].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,pf_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[pf_all].data,pf_all,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += pf_len;
				len 	+= pf_len;

				if(cur_regs[q_c].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,pf_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[pf_a].data,pf_a,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += pf_len;
				len 	+= pf_len;

				if(cur_regs[q_c].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,pf_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[pf_b].data,pf_b,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += pf_len;
				len 	+= pf_len;


				if(cur_regs[q_c].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,pf_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[pf_c].data,pf_c,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += pf_len;
				len 	+= pf_len;
			}
			return len;
		}
		break;
			
		case RATA_P:	//额定有功功率
  			{
			for (u16 i = 0; i < invSendFrame.regsNextSendSize; i++){
				u16 byte_count = 2 * cur_regs[invSendFrame.regsNextSend[i].reg_flag].reg_count;
				memcpy(invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].data,rxData,byte_count);
				rxData+=getDataLen(cur_regs[invSendFrame.regsNextSend[i].reg_flag].type);
				invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].len = byte_count;
				invSendFrame.regsHaveSend[invSendFrame.regsHaveSendSize++].reg_flag=invSendFrame.regsNextSend[i].reg_flag;
			}

			//清空发送队列
			invSendFrame.regsNextSendSize = 0;
			
			//接收完成
			if (invSendFrame.regsHaveSendSize >= invSendFrame.regsSize) {
			
				if(cur_regs[rated_p].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,p_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[rated_p].data,rated_p,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
					else 
					{
						memcpy((u8*)&intermediateDev[devNum].ratedActivePower,DataBuf,p_len);
					}
				}

				DataBuf += p_len;
				len 	+= p_len;
			}
			return len;
			break;
		}

		case RATA_Q:	//额定无功功率调节
	  	{
			for (u16 i = 0; i < invSendFrame.regsNextSendSize; i++){
				u16 byte_count = 2 * cur_regs[invSendFrame.regsNextSend[i].reg_flag].reg_count;
				memcpy(invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].data,rxData,byte_count);
				rxData+=getDataLen(cur_regs[invSendFrame.regsNextSend[i].reg_flag].type);
				invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].len = byte_count;
				invSendFrame.regsHaveSend[invSendFrame.regsHaveSendSize++].reg_flag=invSendFrame.regsNextSend[i].reg_flag;
			}

			//清空发送队列
			invSendFrame.regsNextSendSize = 0;
			
			//接收完成
			//
			if (invSendFrame.regsHaveSendSize >= invSendFrame.regsSize) {
				
				if(cur_regs[rated_q].flag==inValidFlag)
				{
                    memcpy(DataBuf,(u8*)&faildData,q_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[rated_q].data,rated_q,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
					else
					{
						memcpy((u8*)&intermediateDev[devNum].ratedReactivePower,DataBuf,q_len);
					}
				}
				DataBuf += q_len;
				len 	+= q_len;
			}
			return len;
		}
		break;

		case OUT_TYPE:	//输出类型  
		{

			for (u16 i = 0; i < invSendFrame.regsNextSendSize; i++){
				u16 byte_count = 2 * cur_regs[invSendFrame.regsNextSend[i].reg_flag].reg_count;
				memcpy(invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].data,rxData,byte_count);
				rxData+=2;
				invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].len = byte_count;
				invSendFrame.regsHaveSend[invSendFrame.regsHaveSendSize++].reg_flag=invSendFrame.regsNextSend[i].reg_flag;
			}
			//清空发送队列
			invSendFrame.regsNextSendSize = 0;
			//接收完成
			if (invSendFrame.regsHaveSendSize >= invSendFrame.regsSize) {
				OutTypeg *newOutType=(OutTypeg *)cur_regs[outType].p;
				u16 data=(u16)LoadInt16_BigE(invSendFrame.regValue[outType].data);

				if(cur_regs[outType].type==type_u16)
				{
					if((u8)data==newOutType->val_single)
						DataBuf[0]=gd_single;
					else if((u8)data==newOutType->val_3_phase_3_wire)
						DataBuf[0]=gd_3_phase;
					else if((u8)data==newOutType->val_3_phase_4_wire)
						DataBuf[0]=gd_3_phase;
					else 
						DataBuf[0]=0xff;
				} 
				else if(cur_regs[outType].type==type_char)
				{
					u8 char_data=ascii_char_to_u8((char)(data>>8));
					if((u8)char_data==newOutType->val_single)
					{
						DataBuf[0]=gd_single;
					}
					else if((u8)char_data==newOutType->val_3_phase_3_wire) 
					{
						DataBuf[0]=gd_3_phase;
					}
					else if((u8)char_data==newOutType->val_3_phase_4_wire) 
					{
						DataBuf[0]=gd_3_phase;
					}
					else 
						DataBuf[0]=0xff;
				}
				
				DataBuf += 1;
				len 	+= 1;

			}
			 
			return len;
			break;
		}
		


		case RunStatus:	//运行状态  
			{

			for (u16 i = 0; i < invSendFrame.regsNextSendSize; i++){
				u16 byte_count = 2 * cur_regs[invSendFrame.regsNextSend[i].reg_flag].reg_count;
				memcpy(invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].data,rxData,byte_count);
				rxData+=2;
				invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].len = byte_count;
				invSendFrame.regsHaveSend[invSendFrame.regsHaveSendSize++].reg_flag=invSendFrame.regsNextSend[i].reg_flag;
			}
			//清空发送队列
			invSendFrame.regsNextSendSize = 0;
			//接收完成
			if (invSendFrame.regsHaveSendSize >= invSendFrame.regsSize) {
				Yk_TurnItemg *newYk=cur_regs[runStatus_rd].p;
				u16 data=LoadInt16_BigE(invSendFrame.regValue[runStatus_rd].data);

				if(cur_regs[runStatus_rd].type==type_BIT)
				{
					if((data&newYk->val_on)==newYk->val_on)
					{
						DataBuf[0]=0;	
					}
					else if((data&newYk->val_off)==newYk->val_off)
					{
						DataBuf[0]=1;
					}
					else
					DataBuf[0]=1;
				} 
				else 
				{
						if(data==newYk->val_on)
						DataBuf[0]=0;
						else if(data==newYk->val_off)
						DataBuf[0]=1;
						else 
						DataBuf[0]=1;
				}
			

				
				DataBuf += 1;
				len 	+= 1;

			}
			
			return len;
			break;
		}
		
		case DEG:	//日发电量
		{
			for (u16 i = 0; i < invSendFrame.regsNextSendSize; i++){
				u16 byte_count = 2 * cur_regs[invSendFrame.regsNextSend[i].reg_flag].reg_count;
				memcpy(invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].data,rxData,byte_count);
				rxData+=getDataLen(cur_regs[invSendFrame.regsNextSend[i].reg_flag].type);
				invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].len = byte_count;
				invSendFrame.regsHaveSend[invSendFrame.regsHaveSendSize++].reg_flag=invSendFrame.regsNextSend[i].reg_flag;
			}

			//清空发送队列
			invSendFrame.regsNextSendSize = 0;
			
			//接收完成
			//
			if (invSendFrame.regsHaveSendSize >= invSendFrame.regsSize) {
				
				if(cur_regs[deg].flag==inValidFlag)
				{
				memcpy(DataBuf,(u8*)&faildData,deg_len);
				}
				else
				{
				status=YCReadDeal(DataBuf,invSendFrame.regValue[deg].data,deg,cur_regs);
				if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += deg_len;
				len 	+= deg_len;
			}
			return len;
			break;
		}

		case P_PCT_SET:	////有功功率百分比读取
			{
			for (u16 i = 0; i < invSendFrame.regsNextSendSize; i++){
				u16 byte_count = 2 * cur_regs[invSendFrame.regsNextSend[i].reg_flag].reg_count;
				memcpy(invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].data,rxData,byte_count);
				rxData+=getDataLen(cur_regs[invSendFrame.regsNextSend[i].reg_flag].type);
				invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].len = byte_count;
				invSendFrame.regsHaveSend[invSendFrame.regsHaveSendSize++].reg_flag=invSendFrame.regsNextSend[i].reg_flag;
			}
			//清空发送队列
			invSendFrame.regsNextSendSize = 0;

			//接收完成
			if (invSendFrame.regsHaveSendSize >= invSendFrame.regsSize) {
				
				if(cur_regs[p_pct_set_num].flag==inValidFlag)
				{
				memcpy(DataBuf,(u8*)&faildData,p_pct_len);
				}
				else
				{
				status=YCReadDeal(DataBuf,invSendFrame.regValue[p_pct_set_num].data,p_pct_set_num,cur_regs);
				if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += p_pct_len;
				len 	+= p_pct_len;
			}
			return len;
		}
		break;

		case Q_PCT_SET:	////无功功率百分比读取
			{
			for (u16 i = 0; i < invSendFrame.regsNextSendSize; i++){
				u16 byte_count = 2 * cur_regs[invSendFrame.regsNextSend[i].reg_flag].reg_count;
				memcpy(invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].data,rxData,byte_count);
				rxData+=getDataLen(cur_regs[invSendFrame.regsNextSend[i].reg_flag].type);
				invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].len = byte_count;
				invSendFrame.regsHaveSend[invSendFrame.regsHaveSendSize++].reg_flag=invSendFrame.regsNextSend[i].reg_flag;
			}
			//清空发送队列
			invSendFrame.regsNextSendSize = 0;
			//接收完成
			if (invSendFrame.regsHaveSendSize >= invSendFrame.regsSize) {
				
				if(cur_regs[q_pct_set_num].flag==inValidFlag)
				{
				memcpy(DataBuf,(u8*)&faildData,q_pct_len);
				}
				else
				{
				status=YCReadDeal(DataBuf,invSendFrame.regValue[q_pct_set_num].data,q_pct_set_num,cur_regs);
				if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += q_pct_len;
				len 	+= q_pct_len;
			}
			return len;
		}
		break;

		case P_SET:	////有功功率读取
        {
			for (u16 i = 0; i < invSendFrame.regsNextSendSize; i++){
				u16 byte_count = 2 * cur_regs[invSendFrame.regsNextSend[i].reg_flag].reg_count;
				memcpy(invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].data,rxData,byte_count);
				rxData+=getDataLen(cur_regs[invSendFrame.regsNextSend[i].reg_flag].type);
				invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].len = byte_count;
				invSendFrame.regsHaveSend[invSendFrame.regsHaveSendSize++].reg_flag=invSendFrame.regsNextSend[i].reg_flag;
			}
			//清空发送队列
			invSendFrame.regsNextSendSize = 0;
			//接收完成
			if (invSendFrame.regsHaveSendSize >= invSendFrame.regsSize) {
				
				if(cur_regs[p_set_num].flag==inValidFlag)
				{
				memcpy(DataBuf,(u8*)&faildData,p_len);
				}
				else
				{
				status=YCReadDeal(DataBuf,invSendFrame.regValue[p_set_num].data,p_set_num,cur_regs);
				if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += p_len;
				len 	+= p_len;
			}
			return len;
		}
		break;

		case Q_SET:	////无功功率读取
			{
			for (u16 i = 0; i < invSendFrame.regsNextSendSize; i++){
				u16 byte_count = 2 * cur_regs[invSendFrame.regsNextSend[i].reg_flag].reg_count;
				memcpy(invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].data,rxData,byte_count);
				rxData+=getDataLen(cur_regs[invSendFrame.regsNextSend[i].reg_flag].type);
				invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].len = byte_count;
				invSendFrame.regsHaveSend[invSendFrame.regsHaveSendSize++].reg_flag=invSendFrame.regsNextSend[i].reg_flag;
			}
			//清空发送队列
			invSendFrame.regsNextSendSize = 0;
			//接收完成
			if (invSendFrame.regsHaveSendSize >= invSendFrame.regsSize) {
				
				if(cur_regs[q_set_num].flag==inValidFlag)
				{
				memcpy(DataBuf,(u8*)&faildData,q_len);
				}
				else
				{
				status=YCReadDeal(DataBuf,invSendFrame.regValue[q_set_num].data,q_set_num,cur_regs);
				if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += q_len;
				len 	+= q_len;
			}
			return len;
		}
		break;

		case PF_SET:	////功率因数读取
			{
			for (u16 i = 0; i < invSendFrame.regsNextSendSize; i++){
				u16 byte_count = 2 * cur_regs[invSendFrame.regsNextSend[i].reg_flag].reg_count;
				memcpy(invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].data,rxData,byte_count);
				rxData+=getDataLen(cur_regs[invSendFrame.regsNextSend[i].reg_flag].type);
				invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].len = byte_count;
				invSendFrame.regsHaveSend[invSendFrame.regsHaveSendSize++].reg_flag=invSendFrame.regsNextSend[i].reg_flag;
			}
			//清空发送队列
			invSendFrame.regsNextSendSize = 0;
			//接收完成
			if (invSendFrame.regsHaveSendSize >= invSendFrame.regsSize) {
				
				if(cur_regs[p_pct_set_num].flag==inValidFlag)
				{
				memcpy(DataBuf,(u8*)&faildData,p_pct_len);
				}
				else
				{
				status=YCReadDeal(DataBuf,invSendFrame.regValue[p_pct_set_num].data,p_pct_set_num,cur_regs);
				if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += p_pct_len;
				len 	+= p_pct_len;
			}
			return len;
		}
		break;


		case Switch_Status:	//运行状态  
		{

			for (u16 i = 0; i < invSendFrame.regsNextSendSize; i++){
				u16 byte_count = 2 * cur_regs[invSendFrame.regsNextSend[i].reg_flag].reg_count;
				memcpy(invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].data,rxData,byte_count);
				rxData+=2;
				invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].len = byte_count;
				invSendFrame.regsHaveSend[invSendFrame.regsHaveSendSize++].reg_flag=invSendFrame.regsNextSend[i].reg_flag;
			}
			//清空发送队列
			invSendFrame.regsNextSendSize = 0;
			//接收完成
			if (invSendFrame.regsHaveSendSize >= invSendFrame.regsSize) {
				u16 data=LoadInt16_BigE(invSendFrame.regValue[switch_BitStatus].data);

			//清空发送队列
			invSendFrame.regsNextSendSize = 0;
			//接收完成
			if (invSendFrame.regsHaveSendSize >= invSendFrame.regsSize) {
				
				if(cur_regs[switch_BitStatus].flag==inValidFlag)
				{
				memcpy(DataBuf,(u8*)&faildData,swt_stat_len);
				}
				else
				{
				status=YCReadDeal(DataBuf,invSendFrame.regValue[switch_BitStatus].data,switch_BitStatus,cur_regs);
				if(status==false)
					{
						len =0;
						return len;
					}
				}
				DataBuf += swt_stat_len;
				len 	+= swt_stat_len;
			}
			return len;
			}
			break;
		}


		case YT_DATA:	
		{
			for (u16 i = 0; i < invSendFrame.regsNextSendSize; i++){
				u16 byte_count = 2 * cur_regs[invSendFrame.regsNextSend[i].reg_flag].reg_count;
	

				memcpy(invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].data,rxData,byte_count);
				rxData+=getDataLen(cur_regs[invSendFrame.regsNextSend[i].reg_flag].type);
				invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].len = byte_count;
				invSendFrame.regsHaveSend[invSendFrame.regsHaveSendSize++].reg_flag=invSendFrame.regsNextSend[i].reg_flag;
			}
			//清空发送队列
			invSendFrame.regsNextSendSize = 0;
			//接收完成
			if (invSendFrame.regsHaveSendSize >= invSendFrame.regsSize) {

				if(cur_regs[rated_p].flag==inValidFlag)
				{
					memcpy(DataBuf,(u8*)&faildData,p_len);
				}
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[rated_p].data,rated_p,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
					else
					{
						memcpy((u8*)&intermediateDev[devNum].ratedActivePower,DataBuf,p_len);
					}
				}
				

				if(cur_regs[rated_q].flag==inValidFlag)
				{
                    memcpy(DataBuf,(u8*)&faildData,q_len);
				}
				else
				{
                    status=YCReadDeal(DataBuf,invSendFrame.regValue[rated_q].data,rated_q,cur_regs);\

                    memcpy((u8*)&intermediateDev[devNum].ratedReactivePower,DataBuf,q_len);
                    // intermediateDev[devNum].ratedReactivePower=BcdToBin(DataBuf,q_len);
                    if(status==false)
                    {
                        len =0;
                        return len;
                    }
				}

				if(cur_regs[p_set_num].flag==inValidFlag)
				{
                    memcpy(DataBuf,(u8*)&faildData,p_len);
                }
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[p_set_num].data,p_set_num,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
                    }
				}

				if(cur_regs[q_set_num].flag==inValidFlag)
				{
                    memcpy(DataBuf,(u8*)&faildData,p_len);
                }
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[q_set_num].data,q_set_num,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
                }

				if(cur_regs[pf_set_num].flag==inValidFlag)
				{
                    memcpy(DataBuf,(u8*)&faildData,pf_len);
                }
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[pf_set_num].data,pf_set_num,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
                }

				if(cur_regs[p_pct_set_num].flag==inValidFlag)
				{
                    memcpy(DataBuf,(u8*)&faildData,p_pct_len);
                }
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[p_pct_set_num].data,p_pct_set_num,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
                }

				if(cur_regs[q_pct_set_num].flag==inValidFlag)
				{
                    memcpy(DataBuf,(u8*)&faildData,q_pct_len);
                }
				else
				{
					status=YCReadDeal(DataBuf,invSendFrame.regValue[q_pct_set_num].data,q_pct_set_num,cur_regs);
					if(status==false)
					{
						len =0;
						return len;
					}
                }
			} 
			len=no_resp_645;
			break;
		}

		case ExcepTrigLimit:	//异常事件触发限值
		{
			for (u16 i = 0; i < invSendFrame.regsNextSendSize; i++){
				u16 byte_count = 2 * cur_regs[invSendFrame.regsNextSend[i].reg_flag].reg_count;
				memcpy(invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].data,rxData,byte_count);
				rxData+=getDataLen(cur_regs[invSendFrame.regsNextSend[i].reg_flag].type);
				invSendFrame.regValue[invSendFrame.regsNextSend[i].reg_flag].len = byte_count;
				invSendFrame.regsHaveSend[invSendFrame.regsHaveSendSize++].reg_flag=invSendFrame.regsNextSend[i].reg_flag;
			}

			//清空发送队列
			invSendFrame.regsNextSendSize = 0;
			
			//接收完成
			//
			if (invSendFrame.regsHaveSendSize >= invSendFrame.regsSize) {
				len=no_resp_645; 
			}
			return len;
		}
		break;

		default: 
		len=0;
		break;
	}

	return len;
}
